/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.ipp.zapt

#include <clusters/DoorLock/Commands.h>

#include <app/data-model/Decode.h>
#include <app/data-model/StructDecodeIterator.h>
#include <app/data-model/WrappedStructEncoder.h>

namespace chip {
namespace app {
namespace Clusters {
namespace DoorLock {
namespace Commands {
namespace LockDoor {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LockDoor.
namespace UnlockDoor {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnlockDoor.
namespace UnlockWithTimeout {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTimeout), timeout);
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kTimeout))
        {
            err = DataModel::Decode(reader, timeout);
        }
        else if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnlockWithTimeout.
namespace SetWeekDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
    encoder.Encode(to_underlying(Fields::kStartHour), startHour);
    encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
    encoder.Encode(to_underlying(Fields::kEndHour), endHour);
    encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kDaysMask))
        {
            err = DataModel::Decode(reader, daysMask);
        }
        else if (__context_tag == to_underlying(Fields::kStartHour))
        {
            err = DataModel::Decode(reader, startHour);
        }
        else if (__context_tag == to_underlying(Fields::kStartMinute))
        {
            err = DataModel::Decode(reader, startMinute);
        }
        else if (__context_tag == to_underlying(Fields::kEndHour))
        {
            err = DataModel::Decode(reader, endHour);
        }
        else if (__context_tag == to_underlying(Fields::kEndMinute))
        {
            err = DataModel::Decode(reader, endMinute);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetWeekDaySchedule.
namespace GetWeekDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeekDaySchedule.
namespace GetWeekDayScheduleResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
    encoder.Encode(to_underlying(Fields::kStartHour), startHour);
    encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
    encoder.Encode(to_underlying(Fields::kEndHour), endHour);
    encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kDaysMask))
        {
            err = DataModel::Decode(reader, daysMask);
        }
        else if (__context_tag == to_underlying(Fields::kStartHour))
        {
            err = DataModel::Decode(reader, startHour);
        }
        else if (__context_tag == to_underlying(Fields::kStartMinute))
        {
            err = DataModel::Decode(reader, startMinute);
        }
        else if (__context_tag == to_underlying(Fields::kEndHour))
        {
            err = DataModel::Decode(reader, endHour);
        }
        else if (__context_tag == to_underlying(Fields::kEndMinute))
        {
            err = DataModel::Decode(reader, endMinute);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeekDayScheduleResponse.
namespace ClearWeekDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearWeekDaySchedule.
namespace SetYearDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetYearDaySchedule.
namespace GetYearDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetYearDaySchedule.
namespace GetYearDayScheduleResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetYearDayScheduleResponse.
namespace ClearYearDaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearYearDaySchedule.
namespace SetHolidaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else if (__context_tag == to_underlying(Fields::kOperatingMode))
        {
            err = DataModel::Decode(reader, operatingMode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetHolidaySchedule.
namespace GetHolidaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetHolidaySchedule.
namespace GetHolidayScheduleResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else if (__context_tag == to_underlying(Fields::kOperatingMode))
        {
            err = DataModel::Decode(reader, operatingMode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetHolidayScheduleResponse.
namespace ClearHolidaySchedule {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearHolidaySchedule.
namespace SetUser {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationType), operationType);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserName), userName);
    encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kOperationType))
        {
            err = DataModel::Decode(reader, operationType);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserName))
        {
            err = DataModel::Decode(reader, userName);
        }
        else if (__context_tag == to_underlying(Fields::kUserUniqueID))
        {
            err = DataModel::Decode(reader, userUniqueID);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialRule))
        {
            err = DataModel::Decode(reader, credentialRule);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetUser.
namespace GetUser {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetUser.
namespace GetUserResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserName), userName);
    encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
    encoder.Encode(to_underlying(Fields::kCredentials), credentials);
    encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
    encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
    encoder.Encode(to_underlying(Fields::kNextUserIndex), nextUserIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserName))
        {
            err = DataModel::Decode(reader, userName);
        }
        else if (__context_tag == to_underlying(Fields::kUserUniqueID))
        {
            err = DataModel::Decode(reader, userUniqueID);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialRule))
        {
            err = DataModel::Decode(reader, credentialRule);
        }
        else if (__context_tag == to_underlying(Fields::kCredentials))
        {
            err = DataModel::Decode(reader, credentials);
        }
        else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
        {
            err = DataModel::Decode(reader, creatorFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
        {
            err = DataModel::Decode(reader, lastModifiedFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextUserIndex))
        {
            err = DataModel::Decode(reader, nextUserIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetUserResponse.
namespace ClearUser {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearUser.
namespace SetCredential {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationType), operationType);
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kOperationType))
        {
            err = DataModel::Decode(reader, operationType);
        }
        else if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialData))
        {
            err = DataModel::Decode(reader, credentialData);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetCredential.
namespace SetCredentialResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
        {
            err = DataModel::Decode(reader, nextCredentialIndex);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetCredentialResponse.
namespace GetCredentialStatus {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetCredentialStatus.
namespace GetCredentialStatusResponse {

CHIP_ERROR Type::Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredentialExists), credentialExists);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
    encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
    encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
    encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kCredentialExists))
        {
            err = DataModel::Decode(reader, credentialExists);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
        {
            err = DataModel::Decode(reader, creatorFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
        {
            err = DataModel::Decode(reader, lastModifiedFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
        {
            err = DataModel::Decode(reader, nextCredentialIndex);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialData))
        {
            err = DataModel::Decode(reader, credentialData);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetCredentialStatusResponse.
namespace ClearCredential {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearCredential.
namespace UnboltDoor {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnboltDoor.
namespace SetAliroReaderConfig {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSigningKey), signingKey);
    encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
    encoder.Encode(to_underlying(Fields::kGroupIdentifier), groupIdentifier);
    encoder.Encode(to_underlying(Fields::kGroupResolvingKey), groupResolvingKey);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kSigningKey))
        {
            err = DataModel::Decode(reader, signingKey);
        }
        else if (__context_tag == to_underlying(Fields::kVerificationKey))
        {
            err = DataModel::Decode(reader, verificationKey);
        }
        else if (__context_tag == to_underlying(Fields::kGroupIdentifier))
        {
            err = DataModel::Decode(reader, groupIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kGroupResolvingKey))
        {
            err = DataModel::Decode(reader, groupResolvingKey);
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetAliroReaderConfig.
namespace ClearAliroReaderConfig {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        uint8_t __context_tag = 0;
        CHIP_ERROR err        = __iterator.Next(__context_tag);
        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
        ReturnErrorOnFailure(err);

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearAliroReaderConfig.
} // namespace Commands
} // namespace DoorLock
} // namespace Clusters
} // namespace app
} // namespace chip
